home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc Development Framework / ODFDev / ODF / Found / FWString / Sources / FWStrToo.cpp < prev   
Encoding:
Text File  |  1995-11-08  |  16.1 KB  |  527 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWStrToo.cpp
  4. //    Release Version:    $ 1.0d11 $
  5. //
  6. //    Copyright:    (c) 1993, 1995 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "FWFound.hpp"
  11.  
  12. #ifndef FWPRISTR_H
  13. #include "FWPriStr.h"
  14. #endif
  15.  
  16. #ifndef FWPRIDEB_H
  17. #include "FWPriDeb.h"
  18. #endif
  19.  
  20. #ifndef FWCHARIT_H
  21. #include "FWCharIt.h"
  22. #endif
  23.  
  24. #ifndef FWSTRTOO_H
  25. #include "FWStrToo.h"
  26. #endif
  27.  
  28. #ifndef FWEXCLIB_H
  29. #include "FWExcLib.h"
  30. #endif
  31.  
  32. #include <ctype.h>
  33.  
  34. #if FW_LIB_EXPORT_PRAGMAS
  35. #pragma lib_export on
  36. #endif
  37.  
  38. #ifdef FW_BUILD_MAC
  39. #pragma segment Strings
  40. #endif
  41.  
  42. //========================================================================================
  43. // CLASS FW_CStringTool
  44. //========================================================================================
  45.  
  46. //----------------------------------------------------------------------------------------
  47. // FW_CStringTool::GetTool
  48. //----------------------------------------------------------------------------------------
  49.  
  50. FW_CStringTool*& FW_CStringTool::GetTool()
  51. {
  52. //    const int kOffset = 166;
  53. //    FW_CStringTool **tool = (FW_CStringTool **)
  54. //                FW_CPrivTaskGlobals::GetTaskGlobals(kOffset);
  55.     static FW_CStringTool *sFW_CStringTool;
  56.     return sFW_CStringTool;
  57. }
  58.  
  59. //----------------------------------------------------------------------------------------
  60. //    FW_CStringTool::GetCurrentStringTool
  61. //----------------------------------------------------------------------------------------
  62.  
  63. FW_CStringTool* FW_CStringTool::GetCurrentStringTool()
  64. {
  65.     FW_CStringTool *&gTool = GetTool();
  66.     if (gTool == NULL)
  67.         gTool = FW_NEW(FW_CMinimalStringTool, ());
  68.     return gTool;
  69. }
  70.  
  71. //----------------------------------------------------------------------------------------
  72. //    FW_CStringTool::SetCurrentStringTool
  73. //----------------------------------------------------------------------------------------
  74.  
  75. FW_CStringTool* 
  76. FW_CStringTool::SetCurrentStringTool(FW_CStringTool* tool)
  77. {
  78.     FW_CStringTool *&gTool = GetTool();
  79.     FW_CStringTool* prior = gTool;
  80.     gTool = tool;
  81.     return prior;
  82. }
  83.  
  84. //----------------------------------------------------------------------------------------
  85. //    FW_CStringTool::FW_CStringTool
  86. //----------------------------------------------------------------------------------------
  87.  
  88. FW_CStringTool::FW_CStringTool(FW_Boolean caseSensitive) :
  89.     fCaseSensitive(caseSensitive)
  90. {
  91. }
  92.  
  93. //----------------------------------------------------------------------------------------
  94. //    FW_CStringTool::~FW_CStringTool
  95. //----------------------------------------------------------------------------------------
  96.  
  97. FW_CStringTool::~FW_CStringTool()
  98. {
  99. }
  100.  
  101. //----------------------------------------------------------------------------------------
  102. //    FW_CStringTool::FW_CStringTool
  103. //----------------------------------------------------------------------------------------
  104.  
  105. FW_Boolean FW_CStringTool::SetCaseSensitivity(FW_Boolean caseSensitive)
  106. {
  107.     FW_Boolean prior = fCaseSensitive;
  108.     fCaseSensitive = caseSensitive;
  109.     return prior;
  110. }
  111.  
  112. //----------------------------------------------------------------------------------------
  113. //    FW_CStringTool::ToUpper
  114. //----------------------------------------------------------------------------------------
  115.  
  116. void FW_CStringTool::ToUpper(FW_CTextReader &input, FW_CTextWriter &output)
  117. {
  118.     input.SetPosition(0);
  119.     FW_Char c;
  120.     while ((c=input.GetCharacterAndAdvance()) != FW_kNulCharacter)
  121.     {
  122.         DoConvertToUpper(&c, 1);
  123.         output.PutCharacterAndAdvance(c);
  124.     }
  125.     output.FlushAndUpdateText();
  126. }
  127.  
  128. //----------------------------------------------------------------------------------------
  129. //    FW_CStringTool::ToUpper
  130. //----------------------------------------------------------------------------------------
  131.  
  132. void FW_CStringTool::ToUpper(FW_CString &string)
  133. {
  134.     DoConvertToUpper((FW_Char*) string.fRepresentation, string.fLength);
  135. }
  136.  
  137. //----------------------------------------------------------------------------------------
  138. //    FW_CStringTool::ToLower
  139. //----------------------------------------------------------------------------------------
  140.  
  141. void FW_CStringTool::ToLower(FW_CTextReader &input, FW_CTextWriter &output)
  142. {
  143.     input.SetPosition(0);
  144.     FW_Char c;
  145.     while ((c=input.GetCharacterAndAdvance()) != FW_kNulCharacter)
  146.     {
  147.         DoConvertToLower(&c, 1);
  148.         output.PutCharacterAndAdvance(c);
  149.     }
  150.     output.FlushAndUpdateText();
  151. }
  152.  
  153. //----------------------------------------------------------------------------------------
  154. //    FW_CStringTool::ToLower
  155. //----------------------------------------------------------------------------------------
  156.  
  157. void FW_CStringTool::ToLower(FW_CString &string)
  158. {
  159.     DoConvertToLower((FW_Char*) string.fRepresentation, string.fLength);
  160. }
  161.                                      
  162. //----------------------------------------------------------------------------------------
  163. //    FW_CStringTool::CompareStrings
  164. //----------------------------------------------------------------------------------------
  165.  
  166. FW_StringCompareResult FW_CStringTool::CompareStrings(
  167.                                     const FW_CString &string1,
  168.                                      const FW_CString &string2)
  169. {
  170.     FW_CStringReader reader1(string1);
  171.     FW_CStringReader reader2(string2);
  172.     return DoCompareStrings(reader1, reader2);
  173. }
  174.  
  175. //----------------------------------------------------------------------------------------
  176. //    FW_CStringTool::FindSubString
  177. //----------------------------------------------------------------------------------------
  178.  
  179. FW_Boolean FW_CStringTool::FindSubString(
  180.                                     FW_CTextReader &reader,
  181.                                     const FW_CString &subString,
  182.                                     FW_CharacterPosition &foundPosition)
  183. {
  184.     FW_CStringReader subStringReader(subString);
  185.     return DoFindSubString(reader, subStringReader, foundPosition);
  186. }
  187.                                  
  188. //----------------------------------------------------------------------------------------
  189. //    FW_CStringTool::FindSubString
  190. //----------------------------------------------------------------------------------------
  191.  
  192. FW_Boolean FW_CStringTool::FindSubString(
  193.                         const FW_CString &string,
  194.                         const FW_CString &subString,
  195.                         FW_CharacterPosition &foundPosition,
  196.                         FW_CharacterPosition startPosition)
  197. {
  198.     FW_CStringReader stringReader(string);
  199.     FW_CStringReader subStringReader(subString);
  200.     stringReader.SetPosition(startPosition);
  201.     return DoFindSubString(stringReader, subStringReader, foundPosition);
  202. }
  203.                                  
  204. //----------------------------------------------------------------------------------------
  205. //    FW_CStringTool::Substitute
  206. //----------------------------------------------------------------------------------------
  207.  
  208. FW_Boolean FW_CStringTool::Substitute(FW_CString &string,
  209.                 const FW_CString &searchString,
  210.                 const FW_CString &substitutionString)
  211. {
  212.     FW_CharacterCount position;
  213.     FW_Boolean found = FindSubString(string, searchString, position, 0);
  214.     if (found)
  215.     {
  216.         string.Delete(searchString.GetLength(), position);
  217.         string.Insert(substitutionString, position);
  218.     }
  219.     return found;
  220. }
  221.  
  222. //----------------------------------------------------------------------------------------
  223. //    FW_CStringTool::FindCharacter
  224. //----------------------------------------------------------------------------------------
  225.  
  226. FW_Boolean FW_CStringTool::FindCharacter(
  227.                         const FW_CString &string,
  228.                         FW_LChar character,
  229.                         FW_CharacterPosition &foundPosition,
  230.                         FW_CharacterPosition startPosition,
  231.                         FW_FindDirection direction)
  232. {
  233.     FW_CStringReader reader(string);
  234.     reader.SetPosition(startPosition);
  235.     return DoFindCharacter(reader, character, foundPosition, direction);
  236. }
  237.                                 
  238. //----------------------------------------------------------------------------------------
  239. //    FW_CStringTool::FindWhiteSpace
  240. //----------------------------------------------------------------------------------------
  241.  
  242. FW_Boolean FW_CStringTool::FindWhiteSpace(
  243.                         const FW_CString &string,
  244.                         FW_CharacterPosition &foundPosition,
  245.                         FW_CharacterPosition startPosition,
  246.                         FW_FindDirection direction)
  247. {
  248.     FW_CStringReader reader(string);
  249.     reader.SetPosition(startPosition);
  250.     return DoFindWhiteSpace(reader, foundPosition, direction);
  251. }
  252.                                      
  253. //----------------------------------------------------------------------------------------
  254. //    FW_CStringTool::FindNonWhiteSpace
  255. //----------------------------------------------------------------------------------------
  256.  
  257. FW_Boolean FW_CStringTool::FindNonWhiteSpace(
  258.                             const FW_CString &string,
  259.                             FW_CharacterPosition &foundPosition,
  260.                             FW_CharacterPosition startPosition,
  261.                             FW_FindDirection direction)
  262. {
  263.     FW_CStringReader reader(string);
  264.     reader.SetPosition(startPosition);
  265.     return DoFindNonWhiteSpace(reader, foundPosition, direction);
  266. }
  267.                                      
  268. //----------------------------------------------------------------------------------------
  269. //    FW_CStringTool::IsWhiteSpace
  270. //----------------------------------------------------------------------------------------
  271.  
  272. FW_Boolean FW_CStringTool::IsWhiteSpace(FW_CTextReader &reader)
  273. {
  274.     return DoIsWhiteSpace(reader.PeekCharacter());
  275. }
  276.                                                                  
  277. //========================================================================================
  278. // CLASS FW_CMinimalStringTool
  279. //========================================================================================
  280.  
  281. //----------------------------------------------------------------------------------------
  282. //    FW_CMinimalStringTool::FW_CMinimalStringTool
  283. //----------------------------------------------------------------------------------------
  284.  
  285. FW_CMinimalStringTool::FW_CMinimalStringTool(FW_Boolean caseSensitive) :
  286.     FW_CStringTool(caseSensitive)
  287. {
  288. }
  289.  
  290. //----------------------------------------------------------------------------------------
  291. //    FW_CMinimalStringTool::~FW_CMinimalStringTool
  292. //----------------------------------------------------------------------------------------
  293.  
  294. FW_CMinimalStringTool::~FW_CMinimalStringTool()
  295. {
  296. }
  297.  
  298. //----------------------------------------------------------------------------------------
  299. //    FW_CMinimalStringTool::DoCompareStrings
  300. //----------------------------------------------------------------------------------------
  301.  
  302. FW_StringCompareResult FW_CMinimalStringTool::DoCompareStrings(
  303.                                         FW_CTextReader &reader1,
  304.                                          FW_CTextReader &reader2)
  305. {
  306.     FW_StringCompareResult result = kStringsEqual;
  307.  
  308.     FW_LChar c1;
  309.     FW_LChar c2;
  310.     do
  311.     {
  312.         c1 = reader1.GetCharacterAndAdvance();
  313.         c2 = reader2.GetCharacterAndAdvance();
  314.         if (!fCaseSensitive)
  315.         {
  316.             c1 = ConvertToUpper(c1);
  317.             c2 = ConvertToUpper(c2);
  318.         }
  319.     }  while(c1 == c2 && c1 != FW_kNulCharacter);
  320.     
  321.     if (c1 < c2)
  322.     {
  323.         result = kStringOneLess;
  324.     }
  325.     else if (c1 > c2)
  326.     {
  327.         result = kStringOneGreater;
  328.     }
  329.  
  330.     return result;
  331. }
  332.  
  333. //----------------------------------------------------------------------------------------
  334. //    FW_CMinimalStringTool::DoMatchPrefixString
  335. //----------------------------------------------------------------------------------------
  336.  
  337. FW_Boolean FW_CMinimalStringTool::DoMatchPrefixString(
  338.                                         FW_CTextReader &target,
  339.                                          FW_CTextReader &prefix)
  340. {
  341.     FW_LChar t;
  342.     FW_LChar p;
  343.     
  344.     // check for empty prefix string
  345.     if (prefix.GetLength() == 0)
  346.         return FALSE;
  347.  
  348.     do 
  349.     {
  350.         t = target.GetCharacterAndAdvance();
  351.         p = prefix.GetCharacterAndAdvance();
  352.         if (!fCaseSensitive)
  353.         {
  354.             t = ConvertToUpper(t);
  355.             p = ConvertToUpper(p);
  356.         }
  357.     } while (p!=FW_kNulCharacter && p==t);
  358.     
  359.     // Either p is FW_kNulCharacter, or p!=t.
  360.     // If p is FW_kNulCharacter, then whether p==t or p!=t, there is a prefix match.
  361.     // If p!=t, then there is not a prefix match only if p!=FW_kNulCharacter.
  362.     // Correct determination of match is therefore p==FW_kNulCharacter.
  363.     
  364.     return p==FW_kNulCharacter;
  365. }
  366.                                          
  367. //----------------------------------------------------------------------------------------
  368. //    FW_CMinimalStringTool::DoFindSubString
  369. //----------------------------------------------------------------------------------------
  370.  
  371. FW_Boolean FW_CMinimalStringTool::DoFindSubString(
  372.                                     FW_CTextReader &searchStringReader,
  373.                                     FW_CTextReader &subStringReader,
  374.                                     FW_CharacterPosition &foundPosition)
  375. {
  376.     FW_Boolean match = FALSE;
  377.     
  378.     foundPosition = searchStringReader.GetPosition();
  379.     FW_CharacterPosition lastPosition = searchStringReader.GetLength() - 
  380.                                         subStringReader.GetLength();
  381.     while (foundPosition <= lastPosition)
  382.     {
  383.         subStringReader.SetPosition(0);
  384.         match = DoMatchPrefixString(searchStringReader, subStringReader);
  385.         if (match)
  386.             break;
  387.         searchStringReader.SetPosition(++foundPosition);
  388.     }
  389.  
  390.     return match;
  391. }
  392.  
  393. //----------------------------------------------------------------------------------------
  394. //    FW_CMinimalStringTool::DoFindCharacter
  395. //----------------------------------------------------------------------------------------
  396.  
  397. FW_Boolean FW_CMinimalStringTool::DoFindCharacter(
  398.                                     FW_CTextReader &reader,
  399.                                     FW_LChar character,
  400.                                     FW_CharacterPosition &foundPosition,
  401.                                     FW_FindDirection direction)
  402. {
  403.     if (!fCaseSensitive)
  404.         character = ConvertToUpper(character);
  405.  
  406.     FW_LChar c;
  407.     do
  408.     {
  409.         c = reader.PeekCharacter();
  410.         if (!fCaseSensitive)
  411.             c = ConvertToUpper(c);
  412.         if (c == character || c == FW_kNulCharacter)
  413.             break;
  414.         if (direction == FW_kForwards)
  415.             reader.Advance(1);
  416.         else
  417.             reader.Backup(1);
  418.     } while(1); 
  419.     
  420.     FW_Boolean match = (c == character);
  421.     if (match)
  422.         foundPosition = reader.GetPosition();
  423.  
  424.     return match;
  425. }
  426.  
  427. //----------------------------------------------------------------------------------------
  428. //    FW_CMinimalStringTool::DoFindWhiteSpace
  429. //----------------------------------------------------------------------------------------
  430.  
  431. FW_Boolean FW_CMinimalStringTool::DoFindWhiteSpace(
  432.                                     FW_CTextReader &reader,
  433.                                     FW_CharacterPosition &foundPosition,
  434.                                     FW_FindDirection direction)
  435. {
  436.     FW_Boolean match = FALSE;
  437.  
  438.     FW_LChar c = reader.PeekCharacter();
  439.     while (!DoIsWhiteSpace(c) && c != FW_kNulCharacter)
  440.     {
  441.         if (direction == FW_kForwards)
  442.             reader.Advance(1);
  443.         else
  444.             reader.Backup(1);
  445.         c = reader.PeekCharacter();
  446.     }
  447.     
  448.     if (c != FW_kNulCharacter)    // not at end of string
  449.     {
  450.         match = TRUE;
  451.         foundPosition = reader.GetPosition();
  452.     }
  453.  
  454.     return match;
  455. }
  456.  
  457. //----------------------------------------------------------------------------------------
  458. //    FW_CMinimalStringTool::DoFindNonWhiteSpace
  459. //----------------------------------------------------------------------------------------
  460.  
  461. FW_Boolean FW_CMinimalStringTool::DoFindNonWhiteSpace(
  462.                                     FW_CTextReader &reader,
  463.                                     FW_CharacterPosition &foundPosition,
  464.                                     FW_FindDirection direction)
  465. {
  466.     FW_Boolean match = FALSE;
  467.  
  468.     FW_LChar c = reader.PeekCharacter();
  469.     while (DoIsWhiteSpace(c) && c != FW_kNulCharacter)
  470.     {
  471.         if (direction == FW_kForwards)
  472.             reader.Advance(1);
  473.         else
  474.             reader.Backup(1);
  475.         c = reader.PeekCharacter();
  476.     }
  477.     
  478.     if (c != FW_kNulCharacter)    // not at end of string
  479.     {
  480.         match = TRUE;
  481.         foundPosition = reader.GetPosition();
  482.     }
  483.  
  484.     return match;
  485. }
  486.  
  487. //----------------------------------------------------------------------------------------
  488. //    FW_CMinimalStringTool::DoIsWhiteSpace
  489. //----------------------------------------------------------------------------------------
  490.  
  491. FW_Boolean FW_CMinimalStringTool::DoIsWhiteSpace(FW_LChar character)
  492. {
  493.     // Assumes Roman (1-byte) character set
  494.     return (FW_PrimitiveCharacterIsSpace(character) != 0);
  495. }
  496.  
  497. //----------------------------------------------------------------------------------------
  498. //    FW_CMinimalStringTool::DoConvertToUpper
  499. //----------------------------------------------------------------------------------------
  500.  
  501. void FW_CMinimalStringTool::DoConvertToUpper(FW_Char *chars, FW_CharacterCount length)
  502. {
  503.     // Assumes 1 byte per Roman character
  504.     for (int i=0; i<length; i++)
  505.         chars[i] = FW_PrimitiveCharacterToUpper(chars[i]);
  506. }
  507.  
  508. //----------------------------------------------------------------------------------------
  509. //    FW_CMinimalStringTool::ConvertToUpper
  510. //----------------------------------------------------------------------------------------
  511.  
  512. FW_LChar FW_CMinimalStringTool::ConvertToUpper(FW_LChar character)
  513. {
  514.     return FW_PrimitiveCharacterToUpper(character);
  515. }
  516.  
  517. //----------------------------------------------------------------------------------------
  518. //    FW_CMinimalStringTool::DoConvertToLower
  519. //----------------------------------------------------------------------------------------
  520.  
  521. void FW_CMinimalStringTool::DoConvertToLower(FW_Char *chars, FW_CharacterCount length)
  522. {
  523.     // Assumes 1 byte per Roman character
  524.     for (int i=0; i<length; i++)
  525.         chars[i] = FW_PrimitiveCharacterToLower(chars[i]);
  526. }
  527.